/**
 * c09_float_basics - 浮点数基础：f32与f64
 * 
 * 这是《Rust基础数据类型实战Cookbook》系列的第9个案例
 * 
 * 学习目标：
 * 1. 理解 f32 和 f64 的基本概念和区别
 * 2. 掌握浮点数字面量的各种写法
 * 3. 了解浮点数的存储原理（IEEE 754）
 * 4. 学习浮点数的特殊值处理
 * 5. 掌握浮点数的基本运算操作
 * 6. 理解浮点数精度的概念
 * 7. 学会在实际场景中选择合适的浮点类型
 * 
 * 主要内容：
 * - 单精度浮点数 f32 的特性和使用
 * - 双精度浮点数 f64 的特性和使用
 * - 浮点数字面量和科学计数法
 * - IEEE 754 标准和内存布局
 * - 特殊值：正负无穷、NaN、零值
 * - 浮点数类型转换和精度控制
 * - 实际应用场景分析
 */

fn main() {
    println!("=== Rust 浮点数基础示例 ===\n");

    // 1. 浮点数类型概述
    demonstrate_float_types();
    
    // 2. 浮点数字面量语法
    demonstrate_float_literals();
    
    // 3. IEEE 754 标准和内存表示
    demonstrate_ieee754_layout();
    
    // 4. 特殊值处理
    demonstrate_special_values();
    
    // 5. 基本运算操作
    demonstrate_float_operations();
    
    // 6. 精度和类型转换
    demonstrate_precision_conversion();
    
    // 7. 实际应用场景
    demonstrate_practical_applications();
    
    println!("\n=== 总结 ===");
    println!("浮点数是编程中处理实数的重要工具，掌握其特性对于：");
    println!("- 科学计算和工程应用");
    println!("- 图形处理和游戏开发");
    println!("- 金融计算和数据分析");
    println!("- 物理模拟和算法实现");
    println!("都具有重要意义。");
}

/**
 * 演示浮点数类型的基本概念
 * 
 * 重点知识：
 * - f32 和 f64 的区别和选择
 * - 浮点数的表示范围和精度
 * - 内存占用和性能考虑
 * - 默认类型推断规则
 */
fn demonstrate_float_types() {
    println!("1. 浮点数类型概述");
    println!("   Rust 提供两种浮点数类型：f32（单精度）和 f64（双精度）");
    
    // 1.1 基本类型声明
    println!("\n1.1 基本类型声明");
    
    // f32 - 32位单精度浮点数
    let single_precision: f32 = 3.14159;
    println!("f32 (单精度): {}", single_precision);
    println!("  内存占用: {} 字节", std::mem::size_of::<f32>());
    println!("  有效精度: 约 6-7 位十进制数字");
    
    // f64 - 64位双精度浮点数（默认类型）
    let double_precision: f64 = 3.141592653589793;
    println!("f64 (双精度): {}", double_precision);
    println!("  内存占用: {} 字节", std::mem::size_of::<f64>());
    println!("  有效精度: 约 15-17 位十进制数字");
    
    // 默认类型推断（f64）
    let default_float = 2.718281828;  // 自动推断为 f64
    println!("默认浮点数类型: f64");
    println!("  值: {}", default_float);
    
    // 1.2 数值范围对比
    println!("\n1.2 数值范围对比");
    
    // f32 范围
    println!("f32 数值范围:");
    println!("  最小正值: {}", f32::MIN_POSITIVE);
    println!("  最大值: {}", f32::MAX);
    println!("  最小值: {}", f32::MIN);
    println!("  无穷大: {}", f32::INFINITY);
    println!("  负无穷: {}", f32::NEG_INFINITY);
    
    // f64 范围
    println!("f64 数值范围:");
    println!("  最小正值: {}", f64::MIN_POSITIVE);
    println!("  最大值: {}", f64::MAX);
    println!("  最小值: {}", f64::MIN);
    println!("  无穷大: {}", f64::INFINITY);
    println!("  负无穷: {}", f64::NEG_INFINITY);
    
    // 1.3 选择建议
    println!("\n1.3 类型选择建议:");
    println!("使用 f32 的场景:");
    println!("  - 图形处理（GPU 友好）");
    println!("  - 游戏开发（性能优先）");
    println!("  - 内存受限的嵌入式系统");
    println!("  - 大量浮点数数组（节省内存）");
    
    println!("使用 f64 的场景:");
    println!("  - 科学计算（高精度要求）");
    println!("  - 金融计算（避免舍入误差）");
    println!("  - 数学库和算法实现");
    println!("  - 默认选择（当精度比性能重要时）");
    
    println!("\n{}", "=".repeat(60));
}

/**
 * 演示浮点数字面量的各种写法
 * 
 * 重点知识：
 * - 十进制小数表示法
 * - 科学计数法（指数表示）
 * - 类型后缀指定
 * - 特殊值字面量
 */
fn demonstrate_float_literals() {
    println!("\n2. 浮点数字面量语法");
    println!("   掌握各种浮点数字面量的写法");
    
    // 2.1 基本十进制写法
    println!("\n2.1 基本十进制写法");
    
    // 标准小数形式
    let decimal1 = 3.14159;          // 标准小数
    let decimal2 = 0.5;              // 小于1的小数
    let decimal3 = 42.0;             // 整数加小数点
    let decimal4 = 0.5;              // 省略整数部分的0
    
    println!("标准小数形式:");
    println!("  3.14159 → {}", decimal1);
    println!("  0.5 → {}", decimal2);
    println!("  42.0 → {}", decimal3);
    println!("  .5 → {}", decimal4);
    
    // 2.2 科学计数法
    println!("\n2.2 科学计数法（指数表示）");
    
    // 科学计数法 - 大数
    let scientific1 = 1.23e4;        // 1.23 × 10^4 = 12300
    let scientific2 = 1.5e10;        // 1.5 × 10^10
    let scientific3 = 2E-3;          // 2 × 10^(-3) = 0.002
    let scientific4 = 6.02e23;       // 阿伏伽德罗常数
    
    println!("科学计数法示例:");
    println!("  1.23e4 → {} (1.23 × 10^4)", scientific1);
    println!("  1.5e10 → {} (1.5 × 10^10)", scientific2);
    println!("  2E-3 → {} (2 × 10^(-3))", scientific3);
    println!("  6.02e23 → {} (阿伏伽德罗常数)", scientific4);
    
    // 2.3 类型后缀
    println!("\n2.3 类型后缀指定");
    
    // 明确指定类型
    let f32_value = 3.14159f32;       // 明确指定为 f32
    let f64_value = 2.718281828f64;   // 明确指定为 f64
    let f32_scientific = 1.23e-4f32; // f32 科学计数法
    
    println!("类型后缀示例:");
    println!("  3.14159f32 → {} (f32 类型)", f32_value);
    println!("  2.718281828f64 → {} (f64 类型)", f64_value);
    println!("  1.23e-4f32 → {} (f32 科学计数法)", f32_scientific);
    
    // 2.4 下划线分隔符
    println!("\n2.4 数字分隔符（提高可读性）");
    
    // 使用下划线提高可读性
    let large_number = 1_000_000.5;     // 一百万点五
    let very_small = 0.000_001;         // 百万分之一
    let scientific_readable = 1.234_567e-8; // 科学计数法+分隔符
    
    println!("数字分隔符示例:");
    println!("  1_000_000.5 → {}", large_number);
    println!("  0.000_001 → {}", very_small);
    println!("  1.234_567e-8 → {}", scientific_readable);
    
    // 2.5 常见的数学常数
    println!("\n2.5 常见数学常数表示");
    
    let pi = 3.141592653589793;           // 圆周率 π
    let e = 2.718281828459045;            // 自然常数 e
    let golden_ratio = 1.618033988749895; // 黄金比例 φ
    let sqrt_2 = 1.4142135623730951;      // √2
    
    println!("数学常数:");
    println!("  π (圆周率): {}", pi);
    println!("  e (自然常数): {}", e);
    println!("  φ (黄金比例): {}", golden_ratio);
    println!("  √2: {}", sqrt_2);
    
    println!("\n{}", "=".repeat(60));
}

/**
 * 演示 IEEE 754 标准和内存布局
 * 
 * 重点知识：
 * - IEEE 754 标准的基本概念
 * - 符号位、指数位、尾数位的作用
 * - 浮点数的二进制表示
 * - 精度限制的原因
 */
fn demonstrate_ieee754_layout() {
    println!("\n3. IEEE 754 标准和内存表示");
    println!("   理解浮点数在计算机中的存储方式");
    
    // 3.1 IEEE 754 标准概述
    println!("\n3.1 IEEE 754 标准概述");
    println!("IEEE 754 是浮点数运算的国际标准，定义了浮点数的格式：");
    println!("符号位 | 指数位 | 尾数位（有效数字）");
    
    // f32 布局（32位）
    println!("\nf32 (单精度) 布局：");
    println!("  总位数：32位");
    println!("  符号位：1位 (最高位)");
    println!("  指数位：8位 (次高8位)");
    println!("  尾数位：23位 (低23位)");
    println!("  偏置值：127");
    
    // f64 布局（64位）
    println!("f64 (双精度) 布局：");
    println!("  总位数：64位");
    println!("  符号位：1位 (最高位)");
    println!("  指数位：11位");
    println!("  尾数位：52位");
    println!("  偏置值：1023");
    
    // 3.2 浮点数的组成部分示例
    println!("\n3.2 浮点数的组成部分示例");
    
    let positive_num = 12.25f32;
    let _negative_num = -12.25f32;
    
    println!("示例：12.25 的表示");
    println!("  十进制：{}", positive_num);
    println!("  二进制：1100.01 (12 + 0.25)");
    println!("  科学计数法：1.10001 × 2^3");
    println!("  符号位：0 (正数)");
    println!("  指数：3 + 127(偏置) = 130 = 10000010(二进制)");
    println!("  尾数：10001000...000 (23位)");
    
    println!("示例：-12.25 的表示");
    println!("  与 12.25 相同，只是符号位为 1");
    
    // 3.3 精度限制演示
    println!("\n3.3 精度限制演示");
    
    // f32 精度限制
    let f32_precise = 1.0f32;
    let f32_precision_limit = f32_precise + 1e-8f32;  // 接近 f32 精度极限
    let f32_beyond_precision = f32_precise + 1e-10f32; // 超出 f32 精度
    
    println!("f32 精度限制：");
    println!("  基准值: {}", f32_precise);
    println!("  + 1e-8: {}", f32_precision_limit);
    println!("  + 1e-10: {} (超出精度，可能无变化)", f32_beyond_precision);
    
    // f64 精度限制
    let f64_precise = 1.0f64;
    let f64_precision_limit = f64_precise + 1e-15f64;  // 接近 f64 精度极限
    let f64_beyond_precision = f64_precise + 1e-18f64; // 超出 f64 精度
    
    println!("f64 精度限制：");
    println!("  基准值: {}", f64_precise);
    println!("  + 1e-15: {}", f64_precision_limit);
    println!("  + 1e-18: {} (超出精度，可能无变化)", f64_beyond_precision);
    
    // 3.4 二进制表示查看
    println!("\n3.4 内存中的二进制表示");
    
    let sample_f32 = 3.14159f32;
    let sample_f64 = 3.141592653589793f64;
    
    // 使用 to_bits() 获取二进制表示
    let f32_bits = sample_f32.to_bits();
    let f64_bits = sample_f64.to_bits();
    
    println!("3.14159f32 的内存表示:");
    println!("  十六进制: 0x{:08X}", f32_bits);
    println!("  二进制: {:032b}", f32_bits);
    
    println!("3.141592653589793f64 的内存表示:");
    println!("  十六进制: 0x{:016X}", f64_bits);
    println!("  二进制: {:064b}", f64_bits);
    
    // 从二进制还原
    let restored_f32 = f32::from_bits(f32_bits);
    let restored_f64 = f64::from_bits(f64_bits);
    
    println!("从二进制还原:");
    println!("  f32: {} → {}", sample_f32, restored_f32);
    println!("  f64: {} → {}", sample_f64, restored_f64);
    
    println!("\n{}", "=".repeat(60));
}

/**
 * 演示浮点数的特殊值
 * 
 * 重点知识：
 * - 正无穷大和负无穷大
 * - NaN（不是数字）的概念和产生
 * - 正零和负零的区别
 * - 特殊值的检测方法
 */
fn demonstrate_special_values() {
    println!("\n4. 特殊值处理");
    println!("   了解浮点数系统中的特殊值");
    
    // 4.1 无穷大值
    println!("\n4.1 无穷大值 (Infinity)");
    
    // 正无穷大
    let positive_infinity = f64::INFINITY;
    let neg_infinity = f64::NEG_INFINITY;
    
    println!("无穷大常量:");
    println!("  正无穷大: {}", positive_infinity);
    println!("  负无穷大: {}", neg_infinity);
    
    // 产生无穷大的运算
    let div_by_zero = 1.0 / 0.0;         // 正无穷
    let neg_div_by_zero = -1.0 / 0.0;    // 负无穷
    let overflow_result = f64::MAX * 2.0; // 溢出产生无穷
    
    println!("运算产生的无穷大:");
    println!("  1.0 / 0.0 = {}", div_by_zero);
    println!("  -1.0 / 0.0 = {}", neg_div_by_zero);
    println!("  f64::MAX * 2.0 = {}", overflow_result);
    
    // 无穷大的检测
    println!("无穷大检测:");
    println!("  {} is infinite: {}", positive_infinity, positive_infinity.is_infinite());
    println!("  {} is finite: {}", positive_infinity, positive_infinity.is_finite());
    println!("  {} is positive: {}", positive_infinity, positive_infinity > 0.0);
    
    // 4.2 NaN（不是数字）
    println!("\n4.2 NaN (Not a Number)");
    
    // NaN 常量
    let not_a_number = f64::NAN;
    println!("NaN 常量: {}", not_a_number);
    
    // 产生 NaN 的运算
    let invalid_operations = [
        ("0.0 / 0.0", 0.0 / 0.0),
        ("∞ - ∞", f64::INFINITY - f64::INFINITY),
        ("∞ / ∞", f64::INFINITY / f64::INFINITY),
        ("√(-1)", (-1.0f64).sqrt()),
        ("ln(-1)", (-1.0f64).ln()),
        ("0.0 * ∞", 0.0 * f64::INFINITY),
    ];
    
    println!("产生 NaN 的运算:");
    for (description, result) in invalid_operations {
        println!("  {} = {}", description, result);
    }
    
    // NaN 的特殊性质
    println!("\nNaN 的特殊性质:");
    let nan1 = f64::NAN;
    let nan2 = f64::NAN;
    
    println!("  NaN == NaN: {} (总是 false!)", nan1 == nan2);
    println!("  NaN != NaN: {} (总是 true!)", nan1 != nan2);
    println!("  NaN < 1.0: {} (任何比较都是 false)", nan1 < 1.0);
    println!("  NaN > 1.0: {} (任何比较都是 false)", nan1 > 1.0);
    
    // NaN 检测
    println!("NaN 检测方法:");
    println!("  {}.is_nan(): {}", nan1, nan1.is_nan());
    println!("  {}.is_normal(): {}", nan1, nan1.is_normal());
    
    // 4.3 零值
    println!("\n4.3 零值 (正零和负零)");
    
    let positive_zero = 0.0;
    let negative_zero = -0.0;
    
    println!("零值表示:");
    println!("  正零: {}", positive_zero);
    println!("  负零: {}", negative_zero);
    println!("  正零 == 负零: {}", positive_zero == negative_zero);
    
    // 零值的区别在某些运算中会体现
    let pos_zero_div = 1.0 / positive_zero;  // +∞
    let neg_zero_div = 1.0 / negative_zero;  // -∞
    
    println!("零值运算的区别:");
    println!("  1.0 / +0.0 = {}", pos_zero_div);
    println!("  1.0 / -0.0 = {}", neg_zero_div);
    
    // 4.4 特殊值检测函数总结
    println!("\n4.4 特殊值检测函数总结");
    
    let test_values = [
        ("1.5", 1.5),
        ("0.0", 0.0),
        ("-0.0", -0.0),
        ("∞", f64::INFINITY),
        ("-∞", f64::NEG_INFINITY),
        ("NaN", f64::NAN),
    ];
    
    println!("值       | 正常  | 有限  | 无限  | NaN   | 符号");
    println!("---------|-------|-------|-------|-------|-------");
    
    for (name, value) in test_values {
        println!("{:8} | {:5} | {:5} | {:5} | {:5} | {:5}",
                name,
                value.is_normal(),
                value.is_finite(),
                value.is_infinite(),
                value.is_nan(),
                value.is_sign_positive(),
        );
    }
    
    println!("\n{}", "=".repeat(60));
}

/**
 * 演示浮点数的基本运算
 * 
 * 重点知识：
 * - 四则运算的特点
 * - 浮点数运算的误差
 * - 比较运算的注意事项
 * - 常用数学函数
 */
fn demonstrate_float_operations() {
    println!("\n5. 基本运算操作");
    println!("   掌握浮点数的运算特点和注意事项");
    
    // 5.1 四则运算
    println!("\n5.1 四则运算");
    
    let a = 10.5;
    let b = 3.2;
    
    println!("操作数: a = {}, b = {}", a, b);
    println!("加法: a + b = {}", a + b);
    println!("减法: a - b = {}", a - b);
    println!("乘法: a × b = {}", a * b);
    println!("除法: a ÷ b = {}", a / b);
    println!("取余: a % b = {}", a % b);  // 浮点数也支持取余
    
    // 5.2 运算误差演示
    println!("\n5.2 浮点运算误差");
    
    // 经典的浮点误差例子
    let result1: f64 = 0.1 + 0.2;
    let expected: f64 = 0.3;
    
    println!("经典误差例子:");
    println!("  0.1 + 0.2 = {}", result1);
    println!("  期望结果: {}", expected);
    println!("  相等吗? {}", result1 == expected);
    println!("  差值: {}", (result1 - expected).abs());
    
    // 累积误差
    let mut sum: f64 = 0.0;
    for _ in 0..10 {
        sum += 0.1;
    }
    println!("\n累积误差:");
    println!("  0.1 加 10 次: {}", sum);
    println!("  期望结果: 1.0");
    println!("  相等吗? {}", sum == 1.0);
    println!("  差值: {}", (sum - 1.0).abs());
    
    // 5.3 安全比较方法
    println!("\n5.3 浮点数比较的正确方法");
    
    // 使用 epsilon 进行近似比较
    fn nearly_equal(a: f64, b: f64, epsilon: f64) -> bool {
        (a - b).abs() < epsilon
    }
    
    let x = 0.1 + 0.2;
    let y = 0.3;
    let epsilon = 1e-10;  // 误差容限
    
    println!("近似比较:");
    println!("  x = 0.1 + 0.2 = {}", x);
    println!("  y = 0.3 = {}", y);
    println!("  x == y: {} (直接比较)", x == y);
    println!("  nearly_equal(x, y, {}): {} (容差比较)", epsilon, nearly_equal(x, y, epsilon));
    
    // 相对误差比较
    fn relative_equal(a: f64, b: f64, relative_epsilon: f64) -> bool {
        if a == b {
            true  // 处理无穷大等情况
        } else {
            let diff = (a - b).abs();
            let larger = a.abs().max(b.abs());
            diff <= relative_epsilon * larger
        }
    }
    
    let large_a: f64 = 1000000.1;
    let large_b: f64 = 1000000.2;
    println!("\n相对误差比较 (大数值):");
    println!("  a = {}, b = {}", large_a, large_b);
    println!("  绝对差值: {}", (large_a - large_b).abs());
    println!("  相对误差比较: {}", relative_equal(large_a, large_b, 1e-6));
    
    // 5.4 常用数学函数
    println!("\n5.4 常用数学函数");
    
    let angle = std::f64::consts::PI / 4.0;  // 45度（弧度）
    let number: f64 = 2.718281828;  // e
    
    println!("三角函数 (角度 π/4):");
    println!("  sin(π/4) = {:.6}", angle.sin());
    println!("  cos(π/4) = {:.6}", angle.cos());
    println!("  tan(π/4) = {:.6}", angle.tan());
    
    println!("指数和对数函数:");
    println!("  e^1 = {:.6}", 1.0f64.exp());
    println!("  ln(e) = {:.6}", number.ln());
    println!("  log₁₀(100) = {:.6}", 100.0f64.log10());
    println!("  log₂(8) = {:.6}", 8.0f64.log2());
    
    println!("幂函数和根函数:");
    println!("  2³ = {:.6}", 2.0f64.powf(3.0));
    println!("  √9 = {:.6}", 9.0f64.sqrt());
    println!("  ∛27 = {:.6}", 27.0f64.cbrt());
    
    println!("其他常用函数:");
    println!("  |−5.7| = {:.6}", (-5.7f64).abs());
    println!("  floor(3.7) = {:.6}", 3.7f64.floor());
    println!("  ceil(3.2) = {:.6}", 3.2f64.ceil());
    println!("  round(3.5) = {:.6}", 3.5f64.round());
    println!("  min(5.2, 3.8) = {:.6}", 5.2f64.min(3.8));
    println!("  max(5.2, 3.8) = {:.6}", 5.2f64.max(3.8));
    
    println!("\n{}", "=".repeat(60));
}

/**
 * 演示精度问题和类型转换
 * 
 * 重点知识：
 * - f32 和 f64 之间的转换
 * - 精度丢失的问题
 * - 整数与浮点数的转换
 * - 转换时的注意事项
 */
fn demonstrate_precision_conversion() {
    println!("\n6. 精度问题和类型转换");
    println!("   理解浮点数转换中的精度问题");
    
    // 6.1 f64 到 f32 的转换
    println!("\n6.1 f64 到 f32 的精度丢失");
    
    let high_precision: f64 = 3.141592653589793;  // π 的高精度表示
    let low_precision = high_precision as f32;   // 转换为 f32
    let back_to_f64 = low_precision as f64;      // 再转回 f64
    
    println!("原始 f64 值: {:.15}", high_precision);
    println!("转换为 f32: {:.15}", low_precision);
    println!("再转回 f64: {:.15}", back_to_f64);
    println!("精度丢失: {:.2e}", (high_precision - back_to_f64).abs());
    
    // 6.2 大数值转换的问题
    println!("\n6.2 大数值转换");
    
    let large_f64 = 1e20f64;
    let large_f32 = large_f64 as f32;
    println!("大数值转换:");
    println!("  f64: {} (准确)", large_f64);
    println!("  转为f32: {} (可能有误差)", large_f32);
    println!("  差值: {:.2e}", large_f64 - large_f32 as f64);
    
    // 超出 f32 范围的数值
    let too_large_for_f32 = f64::MAX;
    let overflow_f32 = too_large_for_f32 as f32;
    println!("超出 f32 范围:");
    println!("  f64::MAX: {}", too_large_for_f32);
    println!("  转为f32: {} (溢出为无穷)", overflow_f32);
    
    // 6.3 整数与浮点数转换
    println!("\n6.3 整数与浮点数转换");
    
    // 整数转浮点数
    let integer: i32 = 42;
    let float_from_int = integer as f64;
    println!("整数转浮点: {} → {}", integer, float_from_int);
    
    // 大整数转换的精度问题
    let large_int: i64 = 9007199254740993;  // 超出 f64 精确表示范围
    let float_from_large = large_int as f64;
    let back_to_int = float_from_large as i64;
    
    println!("大整数转换:");
    println!("  原始整数: {}", large_int);
    println!("  转为f64: {}", float_from_large);
    println!("  转回整数: {}", back_to_int);
    println!("  是否相等: {}", large_int == back_to_int);
    
    // 浮点数转整数（截断）
    let float_val = 3.7;
    let truncated = float_val as i32;  // 截断小数部分
    println!("浮点转整数（截断）:");
    println!("  {} → {}", float_val, truncated);
    
    // 6.4 舍入控制
    println!("\n6.4 舍入控制");
    
    let test_values: [f64; 5] = [3.2, 3.5, 3.7, -2.3, -2.7];
    
    println!("不同舍入方式:");
    for val in test_values {
        println!("  {:.1}:", val);
        println!("    截断 (as i32): {}", val as i32);
        println!("    四舍五入: {}", val.round() as i32);
        println!("    向下取整: {}", val.floor() as i32);
        println!("    向上取整: {}", val.ceil() as i32);
    }
    
    // 6.5 安全转换示例
    println!("\n6.5 安全转换示例");
    
    // 检查转换是否安全的函数
    fn safe_f64_to_f32(value: f64) -> Result<f32, &'static str> {
        if value.is_nan() {
            Ok(f32::NAN)
        } else if value.is_infinite() {
            if value.is_sign_positive() {
                Ok(f32::INFINITY)
            } else {
                Ok(f32::NEG_INFINITY)
            }
        } else if value > f32::MAX as f64 {
            Err("值太大，会溢出为无穷")
        } else if value < f32::MIN as f64 {
            Err("值太小，会溢出为负无穷")
        } else if value.abs() < f32::MIN_POSITIVE as f64 && value != 0.0 {
            Err("值太接近0，会变成0")
        } else {
            Ok(value as f32)
        }
    }
    
    let test_conversions = [
        3.14159265359,
        f64::MAX,
        1e-50,
        f64::INFINITY,
        f64::NAN,
    ];
    
    println!("安全转换检查:");
    for value in test_conversions {
        match safe_f64_to_f32(value) {
            Ok(result) => println!("  {} → {} ✓", value, result),
            Err(msg) => println!("  {} → 错误: {}", value, msg),
        }
    }
    
    println!("\n{}", "=".repeat(60));
}

/**
 * 演示实际应用场景
 * 
 * 重点知识：
 * - 科学计算中的浮点数应用
 * - 图形处理和游戏开发
 * - 金融计算的注意事项
 * - 性能优化考虑
 */
fn demonstrate_practical_applications() {
    println!("\n7. 实际应用场景");
    println!("   浮点数在不同领域的实际应用");
    
    // 7.1 科学计算应用
    println!("\n7.1 科学计算应用");
    
    // 物理公式计算：自由落体
    fn free_fall_distance(time: f64, gravity: f64) -> f64 {
        0.5 * gravity * time * time
    }
    
    let earth_gravity = 9.81; // m/s²
    let fall_time = 2.0;      // 秒
    let distance = free_fall_distance(fall_time, earth_gravity);
    
    println!("自由落体计算:");
    println!("  重力加速度: {} m/s²", earth_gravity);
    println!("  下落时间: {} 秒", fall_time);
    println!("  下落距离: {:.2} 米", distance);
    
    // 统计计算：标准差
    fn standard_deviation(data: &[f64]) -> f64 {
        let mean = data.iter().sum::<f64>() / data.len() as f64;
        let variance = data.iter()
            .map(|x| (x - mean).powi(2))
            .sum::<f64>() / data.len() as f64;
        variance.sqrt()
    }
    
    let measurements = [23.1, 24.5, 22.8, 25.2, 23.7, 24.1, 23.9];
    let std_dev = standard_deviation(&measurements);
    let mean = measurements.iter().sum::<f64>() / measurements.len() as f64;
    
    println!("统计分析:");
    println!("  测量数据: {:?}", measurements);
    println!("  平均值: {:.2}", mean);
    println!("  标准差: {:.3}", std_dev);
    
    // 7.2 图形处理应用
    println!("\n7.2 图形处理应用");
    
    // 2D向量结构
    #[derive(Debug, Clone, Copy)]
    struct Vector2D {
        x: f32,  // 图形处理通常使用 f32
        y: f32,
    }
    
    impl Vector2D {
        fn new(x: f32, y: f32) -> Self {
            Vector2D { x, y }
        }
        
        fn length(&self) -> f32 {
            (self.x * self.x + self.y * self.y).sqrt()
        }
        
        fn normalize(&self) -> Self {
            let len = self.length();
            if len > 0.0 {
                Vector2D::new(self.x / len, self.y / len)
            } else {
                Vector2D::new(0.0, 0.0)
            }
        }
        
        fn dot(&self, other: &Vector2D) -> f32 {
            self.x * other.x + self.y * other.y
        }
        
        fn angle_to(&self, other: &Vector2D) -> f32 {
            let dot_product = self.dot(other);
            let lengths = self.length() * other.length();
            if lengths > 0.0 {
                (dot_product / lengths).acos()
            } else {
                0.0
            }
        }
    }
    
    let vector_a = Vector2D::new(3.0, 4.0);
    let vector_b = Vector2D::new(1.0, 1.0);
    
    println!("2D向量计算:");
    println!("  向量A: {:?}, 长度: {:.3}", vector_a, vector_a.length());
    println!("  向量B: {:?}, 长度: {:.3}", vector_b, vector_b.length());
    println!("  A·B (点积): {:.3}", vector_a.dot(&vector_b));
    println!("  夹角: {:.3} 弧度 ({:.1}°)", 
             vector_a.angle_to(&vector_b),
             vector_a.angle_to(&vector_b).to_degrees());
    println!("  A归一化: {:?}", vector_a.normalize());
    
    // 颜色混合
    fn blend_colors(color1: (f32, f32, f32), color2: (f32, f32, f32), factor: f32) -> (f32, f32, f32) {
        let factor = factor.clamp(0.0, 1.0);
        (
            color1.0 * (1.0 - factor) + color2.0 * factor,
            color1.1 * (1.0 - factor) + color2.1 * factor,
            color1.2 * (1.0 - factor) + color2.2 * factor,
        )
    }
    
    let red = (1.0, 0.0, 0.0);
    let blue = (0.0, 0.0, 1.0);
    let blended = blend_colors(red, blue, 0.3);
    
    println!("颜色混合:");
    println!("  红色: RGB{:?}", red);
    println!("  蓝色: RGB{:?}", blue);
    println!("  混合(30%): RGB({:.2}, {:.2}, {:.2})", blended.0, blended.1, blended.2);
    
    // 7.3 金融计算应用
    println!("\n7.3 金融计算应用");
    
    // 复利计算
    fn compound_interest(principal: f64, rate: f64, time: f64, n: f64) -> f64 {
        principal * (1.0 + rate / n).powf(n * time)
    }
    
    let principal = 10000.0;  // 本金
    let annual_rate = 0.05;   // 年利率 5%
    let years = 10.0;         // 投资年数
    let compounds_per_year = 12.0; // 每年复利次数
    
    let final_amount = compound_interest(principal, annual_rate, years, compounds_per_year);
    let interest_earned = final_amount - principal;
    
    println!("复利计算:");
    println!("  本金: ¥{:.2}", principal);
    println!("  年利率: {:.1}%", annual_rate * 100.0);
    println!("  投资期: {} 年", years);
    println!("  复利频率: 每年 {} 次", compounds_per_year);
    println!("  最终金额: ¥{:.2}", final_amount);
    println!("  利息收入: ¥{:.2}", interest_earned);
    
    // 风险价值计算 (简化版 Black-Scholes)
    fn black_scholes_call(s: f64, k: f64, r: f64, t: f64, sigma: f64) -> f64 {
        
        // 正态分布累积分布函数的近似
        fn normal_cdf(x: f64) -> f64 {
            0.5 * (1.0 + (x / (2.0_f64).sqrt()).tanh())
        }
        
        let d1 = ((s / k).ln() + (r + 0.5 * sigma * sigma) * t) / (sigma * (t.sqrt()));
        let d2 = d1 - sigma * (t.sqrt());
        
        s * normal_cdf(d1) - k * (-r * t).exp() * normal_cdf(d2)
    }
    
    let stock_price = 100.0;      // 当前股价
    let strike_price = 105.0;     // 行权价
    let risk_free_rate = 0.05;    // 无风险利率
    let time_to_expiry = 0.25;    // 到期时间（年）
    let volatility = 0.2;         // 波动率
    
    let option_price = black_scholes_call(stock_price, strike_price, risk_free_rate, time_to_expiry, volatility);
    
    println!("期权定价 (Black-Scholes 简化版):");
    println!("  股价: ${:.2}", stock_price);
    println!("  行权价: ${:.2}", strike_price);
    println!("  无风险利率: {:.1}%", risk_free_rate * 100.0);
    println!("  到期时间: {:.2} 年", time_to_expiry);
    println!("  波动率: {:.1}%", volatility * 100.0);
    println!("  看涨期权价格: ${:.4}", option_price);
    
    // 7.4 性能对比
    println!("\n7.4 性能对比 (f32 vs f64)");
    
    // 简单的性能测试
    let iterations = 1_000_000;
    
    // f32 计算
    let start = std::time::Instant::now();
    let mut sum_f32 = 0.0f32;
    for i in 0..iterations {
        sum_f32 += (i as f32).sqrt();
    }
    let duration_f32 = start.elapsed();
    
    // f64 计算
    let start = std::time::Instant::now();
    let mut sum_f64 = 0.0f64;
    for i in 0..iterations {
        sum_f64 += (i as f64).sqrt();
    }
    let duration_f64 = start.elapsed();
    
    println!("性能测试 ({} 次平方根运算):", iterations);
    println!("  f32 耗时: {:?}, 结果: {:.2}", duration_f32, sum_f32);
    println!("  f64 耗时: {:?}, 结果: {:.2}", duration_f64, sum_f64);
    println!("  性能比: f32 比 f64 快 {:.1}%", 
             ((duration_f64.as_nanos() as f64 - duration_f32.as_nanos() as f64) / duration_f64.as_nanos() as f64) * 100.0);
    
    // 7.5 使用建议总结
    println!("\n7.5 类型选择建议总结");
    
    println!("选择 f32 的场景:");
    println!("  ✓ GPU 密集计算（图形渲染、机器学习）");
    println!("  ✓ 大规模数组操作（节省内存）");
    println!("  ✓ 实时系统（游戏、音频处理）");
    println!("  ✓ 嵌入式系统（资源受限）");
    
    println!("选择 f64 的场景:");
    println!("  ✓ 科学计算（高精度需求）");
    println!("  ✓ 金融计算（避免舍入误差）");
    println!("  ✓ 数值分析（误差累积敏感）");
    println!("  ✓ 默认选择（精度优于性能时）");
    
    println!("注意事项:");
    println!("  ⚠️  永远不要直接比较浮点数相等");
    println!("  ⚠️  注意精度丢失和累积误差");
    println!("  ⚠️  处理特殊值（NaN、无穷大）");
    println!("  ⚠️  金融计算考虑使用 Decimal 库");
    
    println!("\n{}", "=".repeat(60));
}
